Thanks for the PR!

Template looks good ✓

Problem: real, observed UX issue. Streaming markdown tables in the interactive TUI exhibit five distinct visual artifacts — cell-by-cell fill-in, width oscillation, vertical-list-then-table flip, raw header text streaming, and a blank hang window before the first row. These are well-documented in prior PRs (#6170, #6340) and represent genuine user-facing polish gaps during live streaming.

Direction: aligned. This is incremental rendering polish for the interactive TUI, a core part of the user experience. Claude Code's CHANGELOG shows a long history of similar streaming/rendering fixes (scroll position jumping, layout jitter, streaming performance improvements), so this area is well within scope.

Approach: five focused refinements across four files, all in packages/cli/src/ui/utils/. Every change is gated on isPending/isStreaming so it only touches the live streaming frontier table — completed tables are unaffected. 308 additions / 32 deletions is reasonable for the scope. No unrelated changes or scope creep.

Moving on to code review. 🔍

— Qwen Code · qwen3.7-max

Code Review

Reviewed the diff against my independent proposal. The PR's approach matches well — I'd have taken the same general strategy (hold back incomplete table state during streaming, bias toward horizontal format, show empty box early). The implementation is clean and well-scoped.

What I looked at:

1. Pre-loop header hold-back (MarkdownDisplay.tsx ~L194–227): Walks backwards from the end to find the start of a pipe-line run, checks code fence state, verifies header has a matching separator before keeping the lines. Correct — the code fence guard prevents false positives on |-leading code block content.

2. Per-row hold-back (MarkdownDisplay.tsx ~L383–403): Enhanced from the previous version to also catch closed-but-incomplete rows (| a | on a 3-column table). The !tableRowMatch || splitMarkdownTableRow(tableRowMatch[1]).length < tableHeaders.length condition correctly covers both unterminated and short-column intermediate states.

3. Horizontal bias (TableRenderer.tsx ~L597–601): !isStreaming && maxRowLines > MAX_ROW_LINES — clean, minimal change that only affects the live frontier.

4. Empty table box (MarkdownDisplay.tsx ~L625, TableRenderer.tsx ~L737–758): Removed tableRows.length > 0 guard for the frontier table, skip middle divider when no data rows. Well-commented rationale.

5. isStreamingFrontier prop flow: Correctly chains through RenderTable → RenderTableInternal → TableRenderer as isStreaming = isPending && isStreamingFrontier. Only the live frontier table gets isStreamingFrontier={true} — completed tables in the same pending message use the normal path.

No critical bugs, no security concerns, no AGENTS.md violations. Code is focused — every change serves the stated goal.

Unit Tests

 ✓  @qwen-code/qwen-code  src/ui/utils/TableRenderer.test.tsx (67 tests) 267ms
 ✓  @qwen-code/qwen-code  src/ui/utils/MarkdownDisplay.test.tsx (144 tests) 642ms

 Test Files  2 passed (2)
      Tests  211 passed (211)

All 211 tests pass. New tests cover all five refinements: atomic rows, width tracking, horizontal bias, header hold-back, empty box rendering, and code block safety.

Tmux Real-Scenario Test

Both the installed build (qwen -p) and the PR code (npm run dev -- -p) were run in tmux with the same prompt asking for a 10-row, 4-column table.

Before (installed build, v0.19.1)

| Capital | Country | Population | Timezone |
|---|---|---|---|
| Tokyo | Japan | 13.96M | UTC+9 |
| Berlin | Germany | 3.75M | UTC+1 |
| Brasília | Brazil | 3.04M | UTC-3 |
| Ottawa | Canada | 1.02M | UTC-5 |
| Canberra | Australia | 457K | UTC+10 |
| Cairo | Egypt | 10.1M | UTC+2 |
| New Delhi | India | 329K | UTC+5:30 |
| Buenos Aires | Argentina | 3.08M | UTC-3 |
| Nairobi | Kenya | 4.73M | UTC+3 |
| Oslo | Norway | 709K | UTC+1 |

After (this PR via dev build)

| Capital | Country | Population | Timezone |
|---------|---------|------------|----------|
| Tokyo | Japan | 13,960,000 | UTC+9 |
| Paris | France | 2,161,000 | UTC+1 |
| Brasília | Brazil | 3,055,000 | UTC-3 |
| Nairobi | Kenya | 4,397,000 | UTC+3 |
| Canberra | Australia | 466,000 | UTC+10 |
| Ottawa | Canada | 1,017,000 | UTC-5 |
| Berlin | Germany | 3,645,000 | UTC+1 |
| New Delhi | India | 321,000 | UTC+5:30 |
| Cairo | Egypt | 10,100,000 | UTC+2 |
| Mexico City | Mexico | 9,209,000 | UTC-6 |

Note: Print mode (-p) outputs raw markdown — the TUI box-drawing rendering (the actual fix target) only appears in interactive mode. Both builds produce correct table data. The visual refinements (hold-back, horizontal bias, empty box, atomic rows) can only be verified in the interactive Ink-based TUI during live streaming, which requires an interactive model session. The unit tests comprehensively cover all five behaviors with 211 passing assertions.

— Qwen Code · qwen3.7-max

Reflection

This PR is a clean, well-scoped follow-up to #6170 and #6340 — each of the five refinements addresses a specific, documented streaming-table artifact. The implementation matches what I'd have done independently: hold back incomplete state at the frontier, bias toward horizontal format, show the empty box early to avoid the blank-hang illusion.

The code is straightforward. The isStreamingFrontier prop is a clean abstraction that correctly isolates the live frontier table from completed tables in the same pending message. The pre-loop header hold-back is the most intricate piece, but it's well-guarded (code fence check, column count match) and handles the edge cases.

211 unit tests pass, covering all five behaviors plus the code-block safety net. The tmux test in -p mode confirms both builds produce correct table data; the interactive TUI visual rendering (the actual fix target) isn't capturable in -p mode, but the unit tests exercise the rendering logic thoroughly.

No scope creep, no unrelated changes, no over-abstraction. Every line in the diff serves the stated goal. The comments explain why without being verbose. This is the kind of focused polish PR that's easy to review, revert if needed, and maintain.

Approved. ✅

— Qwen Code · qwen3.7-max

Please do not rebase or force-push to an active PR as it invalidates existing review comments. Note for future reference, the bots always squash all changes into a single commit automatically as part of the integration.

Good catch — fixed in 53db9ccad.

Zero-row header box on a narrow terminal (TableRenderer.tsx): the width trigger (contentWidth < minHorizontalTableWidth) forced the vertical format, and renderVerticalFormat() over empty rowMetrics yields an empty string — a blank box, exactly the hang the empty-box was meant to avoid. Applied your suggestion so a zero-row table stays horizontal:

const useVerticalFormat =
  (rowMetrics.length > 0 && contentWidth < minHorizontalTableWidth) ||
  (!isStreaming && maxRowLines > MAX_ROW_LINES);

Added a regression test (keeps the zero-row header box horizontal on a narrow terminal, contentWidth 20) asserting the header + box render instead of blank. 212 tests pass, lint clean.

Both [Critical] findings fixed in 431fe2782 (pushed as a new commit, no force-push this time — thanks for the reminder).

1. TableRenderer safety-check path (maxLineWidth > contentWidth - SAFETY_MARGIN): guarded with rowMetrics.length > 0, so a zero-row streaming header box no longer falls through to renderVerticalFormat() (empty string → blank). It stays horizontal even if it slightly overflows a very narrow terminal — visible beats vanished. Test: 6-column zero-row box at contentWidth 25 still renders the box.

2. Pre-loop header hold-back capturing non-table text: now only trims when the first pipe-line is a plausible table header (a complete | … | row, per your suggestion). Un-fenced shell pipelines (| grep foo) and pipe-prefixed log output no longer vanish from the live preview. Test: | grep foo renders as text while pending.

215 tests pass, lint clean.

Heads-up / self-correction: my previous commit 431fe2782 (restricting the header hold-back to a complete | … | row per the [Critical] non-table-text fix) reintroduced the cell-by-cell header flash — while a header is typed (| Alpha, | Alpha | Bet, …) it is not yet a complete row, so it rendered as raw text.

Fixed in 77c5320b8 by discriminating on column count instead of closed-ness: a table header has ≥2 columns; a single-pipe line (| grep foo, pipe-prefixed log) has one cell. The run is held only when its first line has ≥2 cells (closed or not) and no matching separator yet. Net result:

• multi-column header held mid-type → no flash;
• single-pipe non-table text still renders → the earlier [Critical] fix stands (test unchanged).

One residual by necessity: a header still typing its first cell is indistinguishable from a single-pipe line, so it shows briefly until the second column appears — the narrowest flash possible without hiding real pipe text. Added a test for the incomplete multi-column header. 217 tests pass, lint clean.

Update since the earlier review (description refreshed to match):

• Dropped the "horizontal bias" approach (force a live table horizontal while streaming). It backfired for tables that genuinely belong in the vertical label: value format (many columns of long wrapping text): they rendered horizontal while at the frontier, then flipped to vertical once the next block started or on commit — a visible format flip. The format decision is now the same while streaming and once committed, so a table never flips format mid-stream. Removed the now-unused isStreaming / isStreamingFrontier plumbing.
• Also folded in the earlier fixes: multi-column header held mid-type without hiding non-table pipe text; the two zero-row / non-table [Critical] guards.
• Documented one accepted limitation in code: with redraw-on-wider column widths, an extreme long-text table sitting right at the vertical threshold can still oscillate format while streaming (normal tables stay clear).

All commits will squash on merge. npx vitest run packages/cli/src/ui/utils/TableRenderer.test.tsx packages/cli/src/ui/utils/MarkdownDisplay.test.tsx → 217 pass.

Addressed the [Suggestion] on multi-cell non-table pipe content (commit — normal push, no force-push).

Rather than a line-count limit, I keyed on the markdown rule that a table's separator is the line immediately after the header. So once a line follows the held header and doesn't even begin like a separator (optional pipe, optional colon, then a dash), the run is decided as not-a-table and released:

• shell pipelines (| grep foo | wc -l), log excerpts (| 200 | OK | GET /x) and ASCII-art borders now render live instead of being hidden until commit;
• a lone header still being typed (no line after it yet) is still held, so the no-cell-by-cell-flash behavior is unchanged;
• a header whose separator is still being typed (|--) also stays held (it does begin like a separator).

Added a test for the released log-excerpt case. 221 tests pass (152 MarkdownDisplay + 69 TableRenderer), lint clean.

Follow-up (commit — normal push, no force-push): the horizontal-vs-vertical format choice no longer flips mid-stream.

Previously maxRowLines was measured over every row, so a table that started horizontal (short first row) flipped to vertical the moment a later, taller-wrapping row streamed in — a visible format change on a long-text table. It now measures only the header + first data row, so the format is decided once and stays put as rows append. Column widths still track all rows (redraw-on-wider is unchanged); only the format choice is anchored.

Trade-off: a table whose first row is short but a later row wraps very tall stays a (taller) horizontal grid rather than flipping — rare, and preferable to a visible flip. This tightens the earlier "format decision consistent, not streaming-biased" commit (it was consistent for a given row set, but the set grew during streaming).

Added a TableRenderer test (short first row + tall later row stays horizontal). 222 tests pass (70 TableRenderer + 152 MarkdownDisplay), lint clean.

Two follow-up commits (normal push, no force-push):

1. Release a dash-led data row from the hold-back — addresses observation ① from the last review. The couldStillBeTable check treated any post-header line starting with a dash as a possible separator, so an options table whose first data cell is a flag — | --verbose | … | — was held back for the whole stream. Now uses tableSeparatorRegex.test(lineAfterHeader): a partial separator being typed (|--) is still held, but a dash-led data cell (trailing letters) renders live. Added a test.

2. Defer a streaming table until its first row (no empty-box flip) — a recognized table with no complete data row yet was drawn immediately as an empty header box. A zero-row table can only render horizontally (the vertical fallback needs rows to lay out), so once a long first row landed the box flipped to the vertical label: value format — a visible format change. The format genuinely can't be decided from the header alone (column names are short; the width that forces vertical comes from the values). So while pending, defer the table until its first row completes: it first appears already in its final format, no flip. Cost: the table area stays blank while the header + first row stream (the pre-loop trim already hid the header text, so this only extends that blank). Committed tables are unchanged. Updated the empty-box test to assert the deferral.

Together with the earlier first-row-anchored format decision, a streaming table no longer flips horizontal↔vertical at any point. Tests: 156 MarkdownDisplay + 70 TableRenderer pass, lint clean.

Addressed all five findings from the last review (one commit, normal push):

• [Critical] code-fence tracking (MarkdownDisplay.tsx): the pre-loop hold-back used a naive boolean toggle. It now tracks the open fence's delimiter and validates the close (same char, length ≥ open), mirroring the main parser — a nested ```` … ``` no longer mis-closes and hides a code | A | B | line while streaming. Added a nested-fence test.
• Mismatched complete separator: a separator that is already complete (ends with |) but whose column count differs from the header can never match, so it is released instead of held for the whole stream (the main parser treats it as text). Added a test.
• Zero-row EOF/mid asymmetry: the end-of-content flush now uses the same tableRows.length > 0 guard as the mid-content handler, so a degenerate zero-row table behaves identically either way.
• First-row measurement leaked to committed tables: calculateMaxRowLines measured only the first row unconditionally, so a committed short-first-row + tall-later-row table wrongly stayed horizontal. Added an isPending prop to TableRenderer — measure the first row only while streaming (no mid-stream flip), every row once committed (most readable). Added committed-vs-streaming tests.
• Test naming: renamed the block that referenced a nonexistent isStreaming prop.

231 tests pass (160 MarkdownDisplay + 71 TableRenderer), lint clean.

Addressed both suggestions from the last review (one commit, normal push):

• Completed mid-content table flipping format at commit: a table closed by a following line is complete even while the message keeps streaming, but it was still rendered with the first-row-only format anchor — so a short-first-row + tall-later-row mid-content table showed horizontal and then flipped to vertical at commit. Rather than passing isPending={false} there (which would also drop the height clamp and let a big mid-content table overflow), I split the two concerns: the height clamp still tracks whether the message is streaming (mid-content table stays bounded, so the estimator's clamped cost can't under-estimate the render), while the format anchor now tracks whether this table is the streaming frontier. The mid-content flush passes isFrontier={false} (measure all rows → final format now); only the end-of-content frontier table anchors to the first row. Renamed TableRenderer's format-anchor prop isPending → isStreaming to reflect this.
• Tilde-fence coverage: added a test that an open ~~~ fence is not closed by an inner ``` (different char), guarding the fence-char check for tilde fences.

235 tests pass (164 MarkdownDisplay + 71 TableRenderer), lint clean.

Addressed the low-confidence observation from the latest review ($$ math-block fence state divergence) in f05d64c.

The streaming hold-back trim tracked code fences but not display-math blocks, while the main parser pushes $$ … $$ content verbatim (never as a table). So a | a | b | norm/matrix line at the frontier of an open math block was treated as a forming table and blanked until the block closed. The trim's fence scan now also tracks math fences, mirroring the main parser's precedence (code block wins, then math), and skips the hold-back while inside one. Added a regression test (does not hold a pipe line inside an open display-math block); it fails without the guard and passes with it. Full suite: 237 tests pass (71 TableRenderer + 166 MarkdownDisplay), tsc/eslint clean on the touched files.

Thanks — on the two low-confidence observations from the latest review, both are intentional and need no change:

1. isFrontier true→false one-frame format flip when a mid-content table closes. This is the accepted redraw-on-wider trade-off already documented in the code comment (the review notes this). Measuring only the first row while a table is the streaming frontier is what prevents the repeated mid-stream vertical↔horizontal flipping as rows arrive; the cost is that a mid-content table can settle to its all-rows format in a single frame when it stops being the frontier. Eliminating that frame would mean measuring all rows while streaming, which reintroduces the per-row flipping this PR removes. Net trade acknowledged in-code.

2. couldStillBeTable inspects only rest[0] while hasMatchingSeparator scans all of rest. The asymmetry is deliberate and matches GFM semantics: a table's separator must be the line immediately after the header, so "could this still become a table?" is decided solely by rest[0], whereas "is there already a complete matching separator?" scans the run to recognize a fully-formed table. The comment above lineAfterHeader documents this. There is also no permanent hold-back: the trim runs only while isPending, so if a forming separator never completes, the stream ends, isPending flips false, the trim is skipped, and the run renders as raw text — no content loss.

The earlier math-block observation is fixed in f05d64c with a regression test. CI is green; 237 tests pass, tsc/eslint clean.

Note for maintainers — the CHANGES_REQUESTED label is stale.

All findings from the bot's CHANGES_REQUESTED review (06:55Z) have been addressed:

Every subsequent bot review (08:43Z, 10:10Z, 11:43Z) reports 0 high-confidence issues; the remaining items are the bot's own low-confidence observations, addressed in the two comments above ($$ math-block hold-back fixed in f05d64c with a regression test; the isFrontier one-frame trade-off and the rest[0] separator-position asymmetry are intentional and documented in-code).

CI is green and 237 tests pass. The CHANGES_REQUESTED state persists only because the bot has posted COMMENTED reviews since (each noting "Downgraded from Approve to Comment: CI still running"), and a COMMENTED review does not clear a prior CHANGES_REQUESTED — only an APPROVED or a dismissal does. Nothing further is outstanding on the code.

Hi @wenshao — since this PR directly continues #6340 (which you reviewed and merged), would you mind taking a look when you have a chance? 🙏

It's ready from my side:

• All bot review findings are addressed (the per-finding mapping is in the comment above).
• CI is green and 237 tests pass; tsc/eslint clean.
• The remaining CHANGES_REQUESTED state is stale: the bot filed it earlier, then only posted COMMENTED reviews since (each noting "Downgraded from Approve to Comment: CI still running"), and a COMMENTED review doesn't clear a prior CHANGES_REQUESTED — the latest review reports 0 high-confidence issues.

No rush — thanks for your time!

Thanks for the thorough review. Every finding from the review passes has been fixed in follow-up commits (normal pushes — no force-push since the initial squash), and I've now resolved all conversation threads. Summary:

Unit tests green locally:

npx vitest run packages/cli/src/ui/utils/TableRenderer.test.tsx packages/cli/src/ui/utils/MarkdownDisplay.test.tsx

@qwen-code-ci-bot could I get a re-review to clear the stale CHANGES_REQUESTED? Happy to address anything else. 🙏

✅ Local real-build verification — PR #6345

Built this branch (fix/streaming-table-jitter, HEAD f05d64c9) on top of its merge-base 1b58ede8 (#6340, the PR this builds on) and verified the streaming behavior end-to-end on Linux — which also fills the ⚠️ Linux gap in the Tested-on table. Every headline improvement holds; unit tests + lint + types are green. I found no correctness bugs; there is one documentation nit worth fixing before merge (below).

How I verified

Real qwen TUI — streaming a 6-row table (this PR)

• t ≈ 2.5s — only the sentence shows; the header does not stream in as raw | … | text.
• t ≈ 6.5s — rows appear whole, one at a time, as a clean box (redraw-on-wider: the Role column widens once when Secondary lands).
• t ≈ 12s — committed 6-row table, same horizontal format (no flip).

Before (#6340) vs After (#6345) — identical token stream

• Header hold-back ✅ — BEFORE leaks | Name | Role | Team | as raw text; AFTER hides it until the box is ready.
• Atomic rows ✅ — BEFORE renders | Alice | as a row with empty Role/Team cells (and re-widens as each cell lands); AFTER holds the row until all 3 columns arrive, then it appears in one step.
• Widths / no per-token reflow ✅ and format stability while streaming ✅ (a tall row arriving mid-stream does not flip horizontal→vertical — it stays anchored to row 1). | grep foo (single pipe) still renders.

One thing worth fixing before merge — description, not code

The description's "No blank hang — … its header box is drawn immediately (before the first row completes), so the area does not sit blank" (and Evidence → After: "a header box is shown immediately so the area never sits blank") no longer match the shipped code. Commit 30f1610a ("defer a streaming table until its first row (no empty-box flip)") added a tableRows.length > 0 guard at both RenderTable emit sites (MarkdownDisplay.tsx:502 and :718), so a zero-row table is never emitted while pending. The real TUI confirms it: at t ≈ 2.5s the table area is blank (just the preamble) until Alice's row completes.

This is arguably the better behavior — a clean blank beats an empty box that then flips to the vertical label: value layout once a long first row lands — so I'd keep the code and reword the bullet, e.g.:

"the area shows a clean blank (no raw pipe text, no half-filled rows) until the first complete row, avoiding an empty-box → vertical flip."

Side note: with that guard, the zero-row header-box path in TableRenderer.tsx — including the safety-check guard added for the earlier [Critical] review at :782 — is currently unreachable from its only caller (MarkdownDisplay). Harmless / defensive, but worth knowing it isn't exercised on this path.

Minor notes (no action needed)

1. "format stable between streaming and committed" holds during streaming and for uniform tables (verified: streaming format == committed format). A pathological short-first-row / tall-later-row table still flips horizontal→vertical once at commit (streaming anchors to row 1 → horizontal; committed measures all rows → vertical). The calculateMaxRowLines comment already documents this — just noting the Evidence wording is slightly stronger than the behavior.
2. A multi-pipe non-table line (| grep foo | wc -l, ≥2 cells) is held back while streaming until a following non-separator line releases it — reproduced. Accepted tradeoff (such commands are almost always fenced); single-pipe | grep foo renders immediately.

Verdict: the streaming-table improvements are real and verified in the actual app, and are a clear step up from #6340; tests/lint/types green. Recommend a quick reword of the "no blank hang / immediate header box" bullet to match the shipped "defer until first row" behavior before merge — everything else is documented or minor.

🤖 Generated with Claude Code — Claude Opus 4.8 (1M context)

Thanks for the real-app Linux verification and the tmux before/after captures — that's exactly the behavior I was going for. 🙏

You're right that the description drifted from the shipped code. Fixed the PR body: the "No blank hang / immediate header box" bullet (and the Evidence → After line, plus the Chinese mirror) now describe the actual "defer until the first complete row" behavior — a clean blank (no raw pipe text, no half-filled rows) until the first row lands, deliberately avoiding the empty-box → vertical-label: value flip. Kept the code as-is, per your suggestion.

Good catch on the now-unreachable zero-row header-box path in TableRenderer.tsx (including the :782 safety guard from the earlier [Critical]): agreed it's dead from MarkdownDisplay's side after the tableRows.length > 0 guard. I've left it as defensive/documented rather than ripping it out in this PR, since it's the intended contract for that renderer if a future caller ever emits a zero-row table — happy to remove it in a follow-up if you'd prefer it gone.

The two minor notes (short-first/tall-later commit-time flip; multi-pipe non-table hold-back) are both already documented in code as accepted tradeoffs. Nothing else outstanding on my end.

@qwen-code /triage

Thanks for the PR!

Template looks good ✓

Problem: real and observed — streaming markdown tables show visible artifacts (cells trickling in one at a time, whole-table re-widening on a wider cell, header streaming in as raw pipe text). Builds on #6170 and #6340 which addressed related rendering issues. The problem is well-established.

Direction: aligned. TUI streaming polish is core to the product experience. No CHANGELOG reference needed for rendering fixes of this nature, but the area is clearly relevant.

Size: not applicable — all changes are in packages/cli/src/ui/utils/, outside core infrastructure paths.

Approach: scope feels right. Four tightly-coupled files (two source, two test), all focused on the same streaming table rendering problem. The five sub-improvements (atomic rows, width tracking, format stability, header hold-back, defer-until-first-row) each address a specific visible artifact and are well-motivated. No scope creep.

Moving on to code review and testing. 🔍

— Qwen Code · qwen3.7-max

Code Review

The diff is well-structured and focused. Five sub-improvements in MarkdownDisplay.tsx (atomic rows, header hold-back, format stability, defer-until-first-row, code-fence/math-block tracking) each target a specific visible artifact. The separation of isPending (message streaming) from isFrontier (table at streaming edge) in TableRenderer.tsx is clean — the height clamp and format anchor track different concerns and the code comments explain why.

No critical blockers. The edge-case handling is thorough: code fences validate delimiter char and length, math blocks are tracked, non-table pipe lines (| grep foo) still render, mismatched column counts release rather than hold forever. The couldStillBeTable / hasMatchingSeparator asymmetry is deliberate and matches GFM semantics (separator must be the line immediately after the header).

Tests are comprehensive — 166 MarkdownDisplay + 71 TableRenderer, covering streaming vs committed format stability, frontier row hold-back, code-fence nesting, math-block interaction, and zero-row symmetry.

Unit Tests

237 passed (71 TableRenderer + 166 MarkdownDisplay)
tsc --noEmit: clean
eslint --max-warnings 0: clean

Real-Scenario Test (Interactive TUI)

PR code (npm run dev, branch fix/streaming-table-jitter HEAD f05d64c9) running in tmux on Linux. Prompted: "Output a 6-row 3-column markdown table: planet name, distance from sun in AU, number of moons"

TUI output (capture-pane, PR code)

  > Output a 6-row 3-column markdown table: planet name, distance from sun in
    AU, number of moons

  ∴ Thought for 0s (alt+t to expand)

  ◆
    ┌─────────┬────────────────────────┬───────┐
    │ Planet  │ Distance from Sun (AU) │ Moons │
    ├─────────┼────────────────────────┼───────┤
    │ Mercury │ 0.39                   │ 0     │
    ├─────────┼────────────────────────┼───────┤
    │ Venus   │ 0.72                   │ 0     │
    ├─────────┼────────────────────────┼───────┤
    │ Earth   │ 1.00                   │ 1     │
    ├─────────┼────────────────────────┼───────┤
    │ Mars    │ 1.52                   │ 2     │
    ├─────────┼────────────────────────┼───────┤
    │ Jupiter │ 5.20                   │ 95    │
    ├─────────┼────────────────────────┼───────┤
    │ Saturn  │ 9.58                   │ 146   │
    └─────────┴────────────────────────┴───────┘

The table renders as a clean horizontal box — proper box-drawing characters, correct column alignment, no raw pipe text, no empty header box. The model streamed fast enough that the completed table was captured in one snapshot, so I couldn't observe mid-stream cell-by-cell artifacts, but the final rendering is correct and matches the PR's claims.

Non-interactive comparison (installed qwen 0.19.1 vs PR code, -p mode)

Before (installed qwen -p):

| Language | Creator | Year |
|---|---|---|
| C | Dennis Ritchie | 1972 |
| Python | Guido van Rossum | 1991 |
| Java | James Gosling | 1995 |
| JavaScript | Brendan Eich | 1995 |
| Rust | Graydon Hoare | 2010 |
| Go | Robert Griesemer | 2009 |

After (PR code npm run dev -- -p):

| Planet  | Distance (AU) | Moons |
|---------|--------------:|------:|
| Mercury | 0.39          |     0 |
| Venus   | 0.72          |     0 |
| Earth   | 1.00          |     1 |
| Mars    | 1.52          |     2 |
| Jupiter | 5.20          |    95 |
| Saturn  | 9.58          |   146 |

Both produce correct output in -p mode (raw markdown, no TUI rendering). The streaming rendering improvements are only visible in the interactive TUI where the table appeared as a properly-formatted box.

Note: A collaborator (@wenshao) independently verified this PR with real tmux captures on Linux, including before/after screenshots showing the streaming improvements (header hold-back, atomic rows, width tracking, format stability). That verification confirms the streaming behavior claims.

— Qwen Code · qwen3.7-max

Reflection

This PR is a polished, well-scoped follow-up to #6170 and #6340 that addresses the remaining visible artifacts in streaming table rendering. The five sub-improvements (atomic rows, width tracking, format stability, header hold-back, defer-until-first-row) each target a specific, observable jitter and the implementation matches what the PR promises.

The code is complex — the streaming hold-back logic has to track code fences, math blocks, header cell counts, separator column counts, and whether a table is at the frontier or closed by following text. But every piece of complexity is earned: each edge case (nested fences, $$ math, multi-pipe non-table lines, mismatched column counts) has a test and a comment explaining why it matters. The isPending/isFrontier separation is the right abstraction — two genuinely independent concerns (message streaming vs. table streaming) that were previously coupled.

The author has been responsive through multiple review cycles, fixing every finding including a critical code-fence tracking bug. A collaborator independently verified the streaming improvements on Linux with real tmux captures. 237 tests pass, tsc and eslint are clean.

One minor note: the description has been updated to match the shipped "defer until first row" behavior (per @wenshao's review). The now-unreachable zero-row header-box path in TableRenderer.tsx is dead code from MarkdownDisplay's perspective, but it's documented and harmless as defensive code.

Ships cleanly. Ready to merge. ✅

— Qwen Code · qwen3.7-max